/*
 ********************************************************************************
 *                      桂林聚联科技有限公司
 *                           Copyright
 *
 *  文件描述 ： 解析配置文件，确定保存的运行数据，以及是否打印信息
 *
 *
 *  文件名称 ： parseConf.c
 *  创建者   ： 彭怀敏
 *  创建日期 ： 2016-12-06 14:39:33
 *  当前版本 ： 
 ********************************************************************************
*/
#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

// 输出3个print函数，分别是
// m0_print   : 一般打印
// m0_warning : 添加WARNING的打印
// m0_error   : 添加ERROR的打印
typedef struct
{
    unsigned char m0_p;
    unsigned char m0_w;
    unsigned char m0_e;

    unsigned char m1_p;
    unsigned char m1_w;
    unsigned char m1_e;

    unsigned char m2_p;
    unsigned char m2_w;
    unsigned char m2_e;

    unsigned char m3_p;
    unsigned char m3_w;
    unsigned char m3_e;
}print_switch_t;

static print_switch_t ps;

/*
 ********************************************************************************
 *  函数名称 ： parsePrint
 *  函数描述 ： 解析配置文件/opt/switch_print.conf，以确定哪些打印函数被关闭
 *  入口参数 ： 
 *  返回参数 ： 
 *  日期版本 ： 2016-12-06 14:53:43
 ********************************************************************************
*/
void parsePrint(void)
{
    struct dispatch_print_switch_t
    {
        char str_print[16];
        int  offset;
    };

    int code, i, j, offset, find_sep, find_num, isword;
    char line[64], codestr[64];
    FILE *fp;

    const struct dispatch_print_switch_t disp[12] = 
    {
    	{"m0_print",	0},
    	{"m0_warning",	1},
    	{"m0_error",	2},

    	{"m1_print",	3},
    	{"m1_warning",	4},
    	{"m1_error",	5},

    	{"m2_print",	6},
    	{"m2_warning",	7},
    	{"m2_error",	8},

    	{"m3_print",	9},
    	{"m3_warning",	10},
    	{"m3_error",	11},
    };

    ps.m0_p = 1;
    ps.m0_w = 1;
    ps.m0_e = 1;

    ps.m1_p = 1;
    ps.m1_w = 1;
    ps.m1_e = 1;

    ps.m2_p = 1;
    ps.m2_w = 1;
    ps.m2_e = 1;

    ps.m3_p = 1;
    ps.m3_w = 1;
    ps.m3_e = 1;

    fp = fopen("/opt/TR600plus/config/switch_print.conf", "r");
    if(NULL == fp)  return;

    while(fgets(line, 64, fp)){
        if(line[0] == 'm'){
            // copy string to codestr until space ' ' or '='
            for(i = 0; ; i++){
                if((line[i] == '_') || isalnum(line[i]))    isword = 1;
                else                                        isword = 0;

                if(isword)  codestr[i] = line[i];
                else        break;
            }
            codestr[i] = 0;

            // get the offset of the print_switch type
            offset = -1;
            for(j = 0; j < 12; j++){
                if(!strcmp(disp[j].str_print, codestr)){
                    offset = disp[j].offset;
                    break;
                }
            }
            if(offset == -1)    continue;

            // find '=' and digit after it
            find_sep = 0;
            for(; line[i]; i++){
                if(line[i] == '='){
                    find_sep = 1;
                    break;
                }
            }
            if(find_sep){
                find_num = 0;
                for(; line[i]; i++){
                    if((line[i] >= '0') && (line[i] <= '9')){
                        find_num = 1;
                        break;
                    }
                }
                if(find_num){
                    code = strtol(line+i, NULL, 10);

                    *((unsigned char*)&ps + offset) = !!code;
                }
            }
        }
    }
    fclose(fp);
}

/**************************** m0 module **************************************************/
int m0_print(const char* fmt, ...)
{
    va_list args;         //定义一个va_list类型的变量，用来储存单个参数
    int n = 0;

    if(ps.m0_p){
        va_start(args, fmt);  //使args指向可变参数的第一个参数
        n = vprintf(fmt, args);   //直接传递给printf
        va_end(args);         //结束可变参数的获取
    }
    return n;
}

int m0_warning(const char* fmt, ...)
{
    va_list args;         //定义一个va_list类型的变量，用来储存单个参数
    int n = 0;

    if(ps.m0_w){
        va_start(args, fmt);  //使args指向可变参数的第一个参数
        n  = printf("## Module 0 WARNING ##  ");
        n += vprintf(fmt, args);   //直接传递给printf
        va_end(args);         //结束可变参数的获取
    }
    return n;
}

int m0_error(const char* fmt, ...)
{
    va_list args;         //定义一个va_list类型的变量，用来储存单个参数
    int n = 0;

    if(ps.m0_e){
        va_start(args, fmt);  //使args指向可变参数的第一个参数
        n  = printf("## Module 0 ERROR ##  ");
        n += vprintf(fmt, args);   //直接传递给printf
        va_end(args);         //结束可变参数的获取
    }
    return n;
}

/**************************** m1 module **************************************************/
int m1_print(const char* fmt, ...)
{
    va_list args;         //定义一个va_list类型的变量，用来储存单个参数
    int n = 0;

    if(ps.m1_p){
        va_start(args, fmt);  //使args指向可变参数的第一个参数
        n = vprintf(fmt, args);   //直接传递给printf
        va_end(args);         //结束可变参数的获取
    }
    return n;
}

int m1_warning(const char* fmt, ...)
{
    va_list args;         //定义一个va_list类型的变量，用来储存单个参数
    int n = 0;

    if(ps.m1_w){
        va_start(args, fmt);  //使args指向可变参数的第一个参数
        n  = printf("## Module 1 WARNING ##  ");
        n += vprintf(fmt, args);   //直接传递给printf
        va_end(args);         //结束可变参数的获取
    }
    return n;
}


int m1_error(const char* fmt, ...)
{
    va_list args;         //定义一个va_list类型的变量，用来储存单个参数
    int n = 0;

    if(ps.m1_e){
        va_start(args, fmt);  //使args指向可变参数的第一个参数
        n  = printf("## Module 1 ERROR ##  ");
        n += vprintf(fmt, args);   //直接传递给printf
        va_end(args);         //结束可变参数的获取
    }
    return n;
}

int m1_info(const char* fmt, ...)
{
    va_list args;         //定义一个va_list类型的变量，用来储存单个参数
    int n = 0;

    va_start(args, fmt);  //使args指向可变参数的第一个参数
    n  = printf("## Module 1 INFO ##  ");
    n += vprintf(fmt, args);   //直接传递给printf
    va_end(args);         //结束可变参数的获取
    return n;
}

/**************************** m2 module **************************************************/
int m2_print(const char* fmt, ...)
{
    va_list args;         //定义一个va_list类型的变量，用来储存单个参数
    int n = 0;

    if(ps.m2_p){
        va_start(args, fmt);  //使args指向可变参数的第一个参数
        n = vprintf(fmt, args);   //直接传递给printf
        va_end(args);         //结束可变参数的获取
    }
    return n;
}

int m2_warning(const char* fmt, ...)
{
    va_list args;         //定义一个va_list类型的变量，用来储存单个参数
    int n = 0;

    if(ps.m2_w){
        va_start(args, fmt);  //使args指向可变参数的第一个参数
        n  = printf("## Module 2 WARNING ##  ");
        n += vprintf(fmt, args);   //直接传递给printf
        va_end(args);         //结束可变参数的获取
    }
    return n;
}

int m2_error(const char* fmt, ...)
{
    va_list args;         //定义一个va_list类型的变量，用来储存单个参数
    int n = 0;

    if(ps.m2_e){
        va_start(args, fmt);  //使args指向可变参数的第一个参数
        n  = printf("## Module 2 ERROR ##  ");
        n += vprintf(fmt, args);   //直接传递给printf
        va_end(args);         //结束可变参数的获取
    }
    return n;
}

/**************************** m3 module **************************************************/
int m3_print(const char* fmt, ...)
{
    va_list args;         //定义一个va_list类型的变量，用来储存单个参数
    int n = 0;

    if(ps.m3_p){
        va_start(args, fmt);  //使args指向可变参数的第一个参数
        n = vprintf(fmt, args);   //直接传递给printf
        va_end(args);         //结束可变参数的获取
    }
    return n;
}

int m3_warning(const char* fmt, ...)
{
    va_list args;         //定义一个va_list类型的变量，用来储存单个参数
    int n = 0;

    if(ps.m3_w){
        va_start(args, fmt);  //使args指向可变参数的第一个参数
        n  = printf("## Module 3 WARNING ##  ");
        n += vprintf(fmt, args);   //直接传递给printf
        va_end(args);         //结束可变参数的获取
    }
    return n;
}

int m3_error(const char* fmt, ...)
{
    va_list args;         //定义一个va_list类型的变量，用来储存单个参数
    int n = 0;

    if(ps.m3_e){
        va_start(args, fmt);  //使args指向可变参数的第一个参数
        n  = printf("## Module 3 ERROR ##  ");
        n += vprintf(fmt, args);   //直接传递给printf
        va_end(args);         //结束可变参数的获取
    }
    return n;
}

/*
 ********************************************************************************
 *    End  of  File
 ********************************************************************************
*/

